{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a172e1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5d2bc77",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "if torch.cuda.is_available():\n",
    "    device = torch.device('cuda')\n",
    "else:\n",
    "    device = torch.device('cpu')\n",
    "    \n",
    "print('Using PyTorch version:', torch.__version__, ' Device:', device)\n",
    "\n",
    "\n",
    "#1.load data\n",
    "#TODO 进行数据增强跑起来试试看！！！\n",
    "transform = transforms.Compose(\n",
    "    [transforms.ToTensor(),\n",
    "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
    "\n",
    "batch_size = 8\n",
    "\n",
    "#这是已经划分好训练和测试数据集了的\n",
    "trainset = torchvision.datasets.CIFAR100(root='./cifar-100-python', train=True,\n",
    "                                        download=True, transform=transform)\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n",
    "                                          shuffle=True, num_workers=2)\n",
    "\n",
    "testset = torchvision.datasets.CIFAR100(root='./cifar-100-python', train=False,\n",
    "                                       download=True, transform=transform)\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,\n",
    "                                         shuffle=False, num_workers=2)\n",
    "\n",
    "classes = {19: 'cattle', 29: 'dinosaur', 0: 'apple', 11: 'boy', 1: 'aquarium_fish', 86: 'telephone',\n",
    "           90: 'train', 28: 'cup', 23: 'cloud', 31: 'elephant', 39: 'keyboard', 96: 'willow_tree', \n",
    "           82: 'sunflower', 17: 'castle', 71: 'sea', 8: 'bicycle', 97: 'wolf', 80: 'squirrel', \n",
    "           74: 'shrew', 59: 'pine_tree', 70: 'rose', 87: 'television', 84: 'table', 64: 'possum', \n",
    "           52: 'oak_tree', 42: 'leopard', 47: 'maple_tree', 65: 'rabbit', 21: 'chimpanzee', \n",
    "           22: 'clock', 81: 'streetcar', 24: 'cockroach', 78: 'snake', 45: 'lobster', 49: 'mountain', \n",
    "           56: 'palm_tree', 76: 'skyscraper', 89: 'tractor', 73: 'shark', 14: 'butterfly', 9: 'bottle', \n",
    "           6: 'bee', 20: 'chair', 98: 'woman', 36: 'hamster', 55: 'otter', 72: 'seal', 43: 'lion', 51: 'mushroom', \n",
    "           35: 'girl', 83: 'sweet_pepper', 33: 'forest', 27: 'crocodile', 53: 'orange', 92: 'tulip', 50: 'mouse', \n",
    "           15: 'camel', 18: 'caterpillar', 46: 'man', 75: 'skunk', 38: 'kangaroo', 66: 'raccoon', 77: 'snail', \n",
    "           69: 'rocket', 95: 'whale', 99: 'worm', 93: 'turtle', 4: 'beaver', 61: 'plate', 94: 'wardrobe', 68: 'road', \n",
    "           34: 'fox', 32: 'flatfish', 88: 'tiger', 67: 'ray', 30: 'dolphin', 62: 'poppy', 63: 'porcupine', 40: 'lamp', \n",
    "           26: 'crab', 48: 'motorcycle', 79: 'spider', 85: 'tank', 54: 'orchid', 44: 'lizard', 7: 'beetle', 12: 'bridge', \n",
    "           2: 'baby', 41: 'lawn_mower', 37: 'house', 13: 'bus', 25: 'couch', 10: 'bowl', 57: 'pear', 5: 'bed', \n",
    "           60: 'plain', 91: 'trout', 3: 'bear', 58: 'pickup_truck', 16: 'can'}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a687d74c",
   "metadata": {},
   "source": [
    "## 2. Define a ResNet\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "242a1ec2",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "454c52f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# from https://github.com/bubbliiiing/yolov4-tiny-pytorch\n",
    "class CA_Block(nn.Module):\n",
    "    def __init__(self, channel, reduction=16):\n",
    "        super(CA_Block, self).__init__()\n",
    "        \n",
    "        self.conv_1x1 = nn.Conv2d(in_channels=channel, out_channels=channel//reduction, kernel_size=1, stride=1, bias=False)\n",
    " \n",
    "        self.relu   = nn.ReLU()\n",
    "        self.bn     = nn.BatchNorm2d(channel//reduction)\n",
    " \n",
    "        self.F_h = nn.Conv2d(in_channels=channel//reduction, out_channels=channel, kernel_size=1, stride=1, bias=False)\n",
    "        self.F_w = nn.Conv2d(in_channels=channel//reduction, out_channels=channel, kernel_size=1, stride=1, bias=False)\n",
    " \n",
    "        self.sigmoid_h = nn.Sigmoid()\n",
    "        self.sigmoid_w = nn.Sigmoid()\n",
    " \n",
    "    def forward(self, x):\n",
    "        _, _, h, w = x.size()\n",
    "        \n",
    "        x_h = torch.mean(x, dim = 3, keepdim = True).permute(0, 1, 3, 2)\n",
    "        x_w = torch.mean(x, dim = 2, keepdim = True)\n",
    " \n",
    "        x_cat_conv_relu = self.relu(self.bn(self.conv_1x1(torch.cat((x_h, x_w), 3))))\n",
    " \n",
    "        x_cat_conv_split_h, x_cat_conv_split_w = x_cat_conv_relu.split([h, w], 3)\n",
    " \n",
    "        s_h = self.sigmoid_h(self.F_h(x_cat_conv_split_h.permute(0, 1, 3, 2)))\n",
    "        s_w = self.sigmoid_w(self.F_w(x_cat_conv_split_w))\n",
    " \n",
    "        out = x * s_h.expand_as(x) * s_w.expand_as(x)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73f0746b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Note that the org code if from https://github.com/houqb/CoordAttention/blob/main/coordatt.py\n",
    "# CA xu\n",
    "class h_sigmoid(nn.Module):     #通过ReLU6函数实现，将输入的值限制在0到6之间，并输出在0到1之间的值。\n",
    "    def __init__(self, inplace=True):\n",
    "        super(h_sigmoid, self).__init__()\n",
    "        self.relu = nn.ReLU6(inplace=inplace)\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.relu(x + 3) / 6\n",
    "\n",
    "class h_swish(nn.Module):#激活函数，通过对输入进行 h_sigmoid 操作后，将输入乘以激活函数的输出。\n",
    "    def __init__(self, inplace=True):\n",
    "        super(h_swish, self).__init__()\n",
    "        self.sigmoid = h_sigmoid(inplace=inplace)\n",
    "\n",
    "    def forward(self, x):\n",
    "        return x * self.sigmoid(x)\n",
    "\n",
    "class CoordAtt(nn.Module):\n",
    "    def __init__(self, inp, oup, reduction=32):\n",
    "        super(CoordAtt, self).__init__()\n",
    "        self.pool_h = nn.AdaptiveAvgPool2d((None, 1))\n",
    "        self.pool_w = nn.AdaptiveAvgPool2d((1, None))\n",
    "\n",
    "        mip = max(8, inp // reduction)#一个降维比例 reduction 作为参数。\n",
    "\n",
    "        self.conv1 = nn.Conv2d(inp, mip, kernel_size=1, stride=1, padding=0)\n",
    "        self.bn1 = nn.BatchNorm2d(mip)\n",
    "        self.act = h_swish()\n",
    "        \n",
    "        #conv_h 和 conv_w 是两个1x1的卷积层，分别用于生成垂直和水平方向的注意力权重。\n",
    "        self.conv_h = nn.Conv2d(mip, oup, kernel_size=1, stride=1, padding=0)\n",
    "        self.conv_w = nn.Conv2d(mip, oup, kernel_size=1, stride=1, padding=0)\n",
    "        \n",
    "\n",
    "    def forward(self, x):\n",
    "        identity = x\n",
    "        \n",
    "        #对输入在垂直和水平方向进行自适应平均池化操作，得到 x_h 和 x_w。\n",
    "        n,c,h,w = x.size()\n",
    "        x_h = self.pool_h(x)\n",
    "        x_w = self.pool_w(x).permute(0, 1, 3, 2)\n",
    "        \n",
    "        #h、w方向进行拼接 得到注意力特征图y\n",
    "        y = torch.cat([x_h, x_w], dim=2)\n",
    "        y = self.conv1(y)\n",
    "        y = self.bn1(y)\n",
    "        y = self.act(y) \n",
    "        \n",
    "        x_h, x_w = torch.split(y, [h, w], dim=2)\n",
    "        x_w = x_w.permute(0, 1, 3, 2)\n",
    "        \n",
    "        #生成权重注意力\n",
    "        a_h = self.conv_h(x_h).sigmoid()\n",
    "        a_w = self.conv_w(x_w).sigmoid()\n",
    "\n",
    "        out = identity * a_w * a_h\n",
    "\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6435cb5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#残差块\n",
    "#TODO 看具体残差块含义\n",
    "class BasicBlock(nn.Module):\n",
    "    expansion = 1\n",
    "\n",
    "    def __init__(self, in_channel, out_channel, stride=1):\n",
    "        super(BasicBlock, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(in_channel, out_channel, kernel_size=3,\n",
    "                               stride=stride, padding=1, bias=False)\n",
    "        self.bn1 = nn.BatchNorm2d(out_channel)\n",
    "        self.conv2 = nn.Conv2d(out_channel, out_channel, kernel_size=3,\n",
    "                               stride=1, padding=1, bias=False)\n",
    "        self.bn2 = nn.BatchNorm2d(out_channel)\n",
    "        self.shortcut = nn.Sequential()\n",
    "\n",
    "        if stride != 1 or in_channel != self.expansion * out_channel:\n",
    "            self.shortcut = nn.Sequential(\n",
    "                nn.Conv2d(in_channel, self.expansion * out_channel,\n",
    "                          kernel_size=1, stride=stride, bias=False),\n",
    "                nn.BatchNorm2d(self.expansion * out_channel)\n",
    "            )\n",
    "\n",
    "    def forward(self, x):\n",
    "        out = F.relu(self.bn1(self.conv1(x)))\n",
    "        out = self.bn2(self.conv2(out))\n",
    "        out += self.shortcut(x)\n",
    "        out = F.relu(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b30d168",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self, block, num_blocks, num_classes=100):\n",
    "        super(Net, self).__init__()\n",
    "        self.in_channel = 64\n",
    "\n",
    "        self.conv1 = nn.Conv2d(3, 64, kernel_size=3,\n",
    "                               stride=1, padding=1, bias=False)\n",
    "        self.bn1 = nn.BatchNorm2d(64)\n",
    "\n",
    "        self.layer1 = self.make_layer(block, 64, num_blocks[0], stride=1)\n",
    "        self.CA1 = self.make_CA(64)\n",
    "        self.layer2 = self.make_layer(block, 128, num_blocks[1], stride=2)\n",
    "        self.CA2 = self.make_CA(128)\n",
    "        self.layer3 = self.make_layer(block, 256, num_blocks[2], stride=2)\n",
    "        self.CA3 = self.make_CA(256)\n",
    "        self.layer4 = self.make_layer(block, 512, num_blocks[3], stride=2)\n",
    "        self.CA4 = self.make_CA(512)\n",
    "        self.linear = nn.Linear(512 * block.expansion, num_classes)\n",
    "\n",
    "    def make_layer(self, block, out_channel, num_blocks, stride):\n",
    "        strides = [stride] + (num_blocks - 1) * [1]\n",
    "        layers = []\n",
    "        for stride in strides:\n",
    "            layers.append(block(self.in_channel, out_channel, stride))\n",
    "            self.in_channel = out_channel * block.expansion\n",
    "        return nn.Sequential(*layers)\n",
    "    \n",
    "    def make_CA(self, out_channel):\n",
    "        layers = []\n",
    "        #layers.append(CA_Block(self.in_channel, out_channel))\n",
    "        layers.append(CoordAtt(self.in_channel, out_channel))\n",
    "        self.in_channel = out_channel * 1\n",
    "        return nn.Sequential(*layers)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        out = F.relu(self.bn1(self.conv1(x)))\n",
    "        out = self.layer1(out)\n",
    "        out  = self.CA1(out)\n",
    "        out = self.layer2(out)\n",
    "        out  = self.CA2(out)\n",
    "        out = self.layer3(out)\n",
    "        out  = self.CA3(out)\n",
    "        out = self.layer4(out)\n",
    "        out  = self.CA4(out)\n",
    "        out = F.avg_pool2d(out, 4)\n",
    "        out = out.view(out.size(0), -1)\n",
    "        out = self.linear(out)\n",
    "        return out\n",
    "\n",
    "#超参都可以改！！！\n",
    "def ResNet():\n",
    "    return Net(BasicBlock, [2, 2, 2,2])#4个残差块？？？\n",
    "\n",
    "\n",
    "net = ResNet().to(device)\n",
    "print(net)\n",
    "\n",
    "#一些超参\n",
    "import torch.optim as optim\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e493e029",
   "metadata": {},
   "outputs": [],
   "source": [
    "total = 0\n",
    "for data, target in trainloader:\n",
    "    target = target.to(device)\n",
    "    total += target.size(0)\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a9329e77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1,  1000] loss: 4.324\n",
      "[1,  2000] loss: 4.068\n",
      "[1,  3000] loss: 3.936\n",
      "[1,  4000] loss: 3.804\n",
      "[1,  5000] loss: 3.693\n",
      "[1,  6000] loss: 3.545\n",
      "\n",
      "Validation set: Average loss: 0.4242, Accuracy: 1714/10000 (17%)\n",
      "\n",
      "[2,  1000] loss: 3.554\n",
      "[2,  2000] loss: 3.355\n",
      "[2,  3000] loss: 3.208\n",
      "[2,  4000] loss: 3.137\n",
      "[2,  5000] loss: 3.043\n",
      "[2,  6000] loss: 2.971\n",
      "\n",
      "Validation set: Average loss: 0.3507, Accuracy: 2802/10000 (28%)\n",
      "\n",
      "[3,  1000] loss: 2.794\n",
      "[3,  2000] loss: 2.696\n",
      "[3,  3000] loss: 2.630\n",
      "[3,  4000] loss: 2.576\n",
      "[3,  5000] loss: 2.522\n",
      "[3,  6000] loss: 2.458\n",
      "\n",
      "Validation set: Average loss: 0.3064, Accuracy: 3531/10000 (35%)\n",
      "\n",
      "[4,  1000] loss: 2.246\n",
      "[4,  2000] loss: 2.223\n",
      "[4,  3000] loss: 2.195\n",
      "[4,  4000] loss: 2.176\n",
      "[4,  5000] loss: 2.131\n",
      "[4,  6000] loss: 2.108\n",
      "\n",
      "Validation set: Average loss: 0.2658, Accuracy: 4236/10000 (42%)\n",
      "\n",
      "[5,  1000] loss: 1.840\n",
      "[5,  2000] loss: 1.853\n",
      "[5,  3000] loss: 1.856\n",
      "[5,  4000] loss: 1.850\n",
      "[5,  5000] loss: 1.832\n",
      "[5,  6000] loss: 1.798\n",
      "\n",
      "Validation set: Average loss: 0.2390, Accuracy: 4766/10000 (48%)\n",
      "\n",
      "[6,  1000] loss: 1.494\n",
      "[6,  2000] loss: 1.545\n",
      "[6,  3000] loss: 1.543\n",
      "[6,  4000] loss: 1.552\n",
      "[6,  5000] loss: 1.532\n",
      "[6,  6000] loss: 1.539\n",
      "\n",
      "Validation set: Average loss: 0.2309, Accuracy: 4967/10000 (50%)\n",
      "\n",
      "[7,  1000] loss: 1.209\n",
      "[7,  2000] loss: 1.252\n",
      "[7,  3000] loss: 1.280\n",
      "[7,  4000] loss: 1.286\n",
      "[7,  5000] loss: 1.304\n",
      "[7,  6000] loss: 1.313\n",
      "\n",
      "Validation set: Average loss: 0.2309, Accuracy: 5062/10000 (51%)\n",
      "\n",
      "[8,  1000] loss: 0.927\n",
      "[8,  2000] loss: 1.008\n",
      "[8,  3000] loss: 1.041\n",
      "[8,  4000] loss: 1.037\n",
      "[8,  5000] loss: 1.049\n",
      "[8,  6000] loss: 1.061\n",
      "\n",
      "Validation set: Average loss: 0.2346, Accuracy: 5209/10000 (52%)\n",
      "\n",
      "[9,  1000] loss: 0.695\n",
      "[9,  2000] loss: 0.755\n",
      "[9,  3000] loss: 0.814\n",
      "[9,  4000] loss: 0.838\n",
      "[9,  5000] loss: 0.845\n",
      "[9,  6000] loss: 0.851\n",
      "\n",
      "Validation set: Average loss: 0.2334, Accuracy: 5224/10000 (52%)\n",
      "\n",
      "[10,  1000] loss: 0.522\n",
      "[10,  2000] loss: 0.567\n",
      "[10,  3000] loss: 0.643\n",
      "[10,  4000] loss: 0.656\n",
      "[10,  5000] loss: 0.670\n",
      "[10,  6000] loss: 0.704\n",
      "\n",
      "Validation set: Average loss: 0.2515, Accuracy: 5115/10000 (51%)\n",
      "\n",
      "[11,  1000] loss: 0.396\n",
      "[11,  2000] loss: 0.445\n",
      "[11,  3000] loss: 0.493\n",
      "[11,  4000] loss: 0.512\n",
      "[11,  5000] loss: 0.557\n",
      "[11,  6000] loss: 0.548\n",
      "\n",
      "Validation set: Average loss: 0.2519, Accuracy: 5278/10000 (53%)\n",
      "\n",
      "[12,  1000] loss: 0.283\n",
      "[12,  2000] loss: 0.352\n",
      "[12,  3000] loss: 0.388\n",
      "[12,  4000] loss: 0.402\n",
      "[12,  5000] loss: 0.427\n",
      "[12,  6000] loss: 0.431\n",
      "\n",
      "Validation set: Average loss: 0.2799, Accuracy: 5070/10000 (51%)\n",
      "\n",
      "[13,  1000] loss: 0.232\n",
      "[13,  2000] loss: 0.291\n",
      "[13,  3000] loss: 0.295\n",
      "[13,  4000] loss: 0.337\n",
      "[13,  5000] loss: 0.325\n",
      "[13,  6000] loss: 0.357\n",
      "\n",
      "Validation set: Average loss: 0.3022, Accuracy: 5112/10000 (51%)\n",
      "\n",
      "[14,  1000] loss: 0.203\n",
      "[14,  2000] loss: 0.261\n",
      "[14,  3000] loss: 0.247\n",
      "[14,  4000] loss: 0.286\n",
      "[14,  5000] loss: 0.306\n",
      "[14,  6000] loss: 0.301\n",
      "\n",
      "Validation set: Average loss: 0.3083, Accuracy: 5190/10000 (52%)\n",
      "\n",
      "[15,  1000] loss: 0.150\n",
      "[15,  2000] loss: 0.190\n",
      "[15,  3000] loss: 0.221\n",
      "[15,  4000] loss: 0.212\n",
      "[15,  5000] loss: 0.235\n",
      "[15,  6000] loss: 0.254\n",
      "\n",
      "Validation set: Average loss: 0.3263, Accuracy: 5159/10000 (52%)\n",
      "\n",
      "Training Finished\n"
     ]
    }
   ],
   "source": [
    "import torch.optim as optim\n",
    "\n",
    "#注意注意注意： 每次运行这里时 先把前面的above都运行一遍！！！--》即使值改动了epoch 前面的也得执行一遍！！！\n",
    "def validate(loss_vector, accuracy_vector):\n",
    "    net.eval()\n",
    "    total = 0\n",
    "    val_loss, correct = 0, 0\n",
    "    for data, target in testloader:\n",
    "        data = data.to(device)\n",
    "        target = target.to(device)\n",
    "        output = net(data)\n",
    "        val_loss += criterion(output, target).data.item()\n",
    "        _, predicted = torch.max(output.data, 1)\n",
    "        correct += (predicted == target).sum().item()\n",
    "        total += target.size(0)#total就是一个 总数...\n",
    "\n",
    "    val_loss /= total\n",
    "    loss_vector.append(val_loss)\n",
    "\n",
    "    accuracy = 100 * correct / total\n",
    "    accuracy_vector.append(accuracy)\n",
    "\n",
    "    print('\\nValidation set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\n'.format(\n",
    "        val_loss, correct, total, accuracy))\n",
    "       \n",
    "#开始训练 \n",
    "lossv, accv = [], []\n",
    "\n",
    "epochs = 15 #可调整--这里可以变成train函数\n",
    "#train\n",
    "for epoch in range(epochs):  # loop over the dataset multiple times\n",
    "    \n",
    "\n",
    "    running_loss = 0.0\n",
    "    for i, data in enumerate(trainloader, 0):\n",
    "        # get the inputs; data is a list of [inputs, labels]\n",
    "        inputs, labels = data\n",
    "        inputs = inputs.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        # zero the parameter gradients\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # forward + backward + optimize\n",
    "        outputs = net(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        # print statistics\n",
    "        running_loss += loss.item()\n",
    "        if i % 1000 == 999:    # print every 50 mini-batches\n",
    "            print(f'[{epoch+1}, {i+1:5d}] loss: {running_loss / 1000:.3f}')\n",
    "            running_loss = 0.0\n",
    "    validate(lossv, accv)\n",
    "print('Training Finished')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecf62cce",
   "metadata": {},
   "source": [
    "Let’s quickly save our trained model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9d94a16d",
   "metadata": {},
   "outputs": [],
   "source": [
    "PATH = './cifar_net.pth'\n",
    "torch.save(net.state_dict(), PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4c60ea6a",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'validation accuracy,epoch=15')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 500x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 500x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "plt.figure(figsize=(5,3))\n",
    "plt.plot(np.arange(1,epochs+1), lossv)\n",
    "plt.title('validation loss,epoch=%s'%epochs)\n",
    "\n",
    "plt.figure(figsize=(5,3))\n",
    "plt.plot(np.arange(1,epochs+1), accv)\n",
    "plt.title('validation accuracy,epoch=%s'%epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "909e084f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
